COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	S.
C00042 ENDMK
C⊗;
S.


INTERLISP-10   4-JAN-75 ...

Good afternoon, Doug.

(<LENAT>S.;2 . <LISP>LISP.SAV;50104)
←CONCEPTS
(ACTIVE ACTIVE-D-R ACTIVE-EXS ACTIVE-EXS-NOT-BDY ACTIVE-TIES ANY-STRUC
ANYB ANYB-ALGS ANYB-ANAS ANYB-ANYP ANYB-CHECK ANYB-CHECK1 ANYB-CHECK2
ANYB-D-R ANYB-DEFN ANYB-DEFN-NEC ANYB-DEFN-SUF ANYB-EXS ANYB-EXS-BDY
ANYB-EXS-NOT ANYB-EXS-NOT-BDY ANYB-FILLIN ANYB-FILLIN1 ANYB-FILLIN2
ANYB-GENL ANYB-IN-DOM-OF ANYB-IN-RAN-OF ANYB-INT ANYB-INTU ANYB-INV
ANYB-RESTRUC ANYB-SPEC ANYB-SUGG ANYB-TIES ANYB-UP ANYB-UP-NOT ANYB-VIEW
ANYB-WORTH ANYTHING ATOM-OBJ BAG-OF-LISTS BAG-OF-STRUCS BAG-STRUC
BAG-STRUC-DELETE BAG-STRUC-DIFF BAG-STRUC-INSERT BAG-STRUC-INTERSECT
BAG-STRUC-JOIN CANONIZE COALESCE COMPOSE COMPOSE-D-R COMPOSE-EXS 
COMPOSE-EXS-D-R CONJEC CONSTRUCTIVE-OP EMPTY-STRUC FINAL FIRST IDENTITY
INV-OP INVERTED-OP INVERTED-OP-EXS LIST-STRUC LIST-STRUC-DELETE 
LIST-STRUC-INSERT LIST-STRUC-INTERSECT MAP-JOIN MAP-REPLACE MAP-REPLACE2
MULT-STRUC NON-EMPTY-STRUC NONMULT-STRUC NONMULT-STRUC-EXS OBJ-EQUAL
OBJECT OBJECT-EXS OPERATION ORD-OBJ ORD-OBJ-EXS ORD-PAIR OSET-STRUC
OSET-STRUC-DELETE OSET-STRUC-INSERT OSET-STRUC-INTERSECT PREDICATE
PROJ1 PROJ2 REAR RELATION RESTRICT REV-ORD-PAIR SET-OF-LISTS 
SET-OF-STRUCS SET-STRUC SET-STRUC-DELETE SET-STRUC-DIFF SET-STRUC-INSERT
SET-STRUC-INTERSECT STRUC-OF-LISTS STRUC-OF-STRUCS STRUCTURE 
STRUCTURE-DELETE STRUCTURE-DIFF STRUCTURE-EQUAL STRUCTURE-EXS 
STRUCTURE-EXS-BDY STRUCTURE-INSERT STRUCTURE-INTERSECT STRUCTURE-MEMB
TRUTH-VAL UNORD-OBJ UNORD-OBJ-EXS)
←GETP(SET-STRUC WORTH)
(750 700 700 500 400 990 900 1000 800 800 1000)
←
GETP(SET-STRUC-INTERSECT WORTH)
(0)
←
PUT(SET-STRUC-INTERSECT WORTH (800]
(800)
←
(RPLACA(GETP 'SET-STRUC WORTH 400]
(NIL 700 700 500 400 990 900 1000 800 800 1000)
←
(RPLACA(GETP 'SET-STRUC WORTH ) 400]
(400 700 700 500 400 990 900 1000 800 800 1000)
←
RAND-MEMB((A B C D E]
A
←
RAND-MEMB((A B C D E]
C
←
RAND-MEMB((A B C D E]
A
←
RAND-MEMB((A B C D E]
D
←
RAND-MEMB((A B C D E]
D
←
RAND-MEMB((A B C D E]
B
←
RAND-MEMB((A B C D E]
E
←
(START)

 Please type in your last name ( then carriage-return):
FEIGENBAUM

 Almost ready to enter AM's main loop,  Ed.

Ed, you have used AM once before.
Do you feel like you need some refreshing about how to work with it? Y
       AM has 113 concepts to start with,  each with only
 about 5 of its potential 30 facets ( parts) filled in.
       Repeatedly,  AM selects a part of a concept, 
 and tries to fill it in or check it. In this process,  new
 concepts may emerge and be granted full status; in those cases, 
 almost all their parts will be empty at the time of their creation.

       CANDS is a list of suggested future activities for AM.
 Repeatedly,  AM picks a Candidate from CANDS and does what it says.
 A typical Cand might be:
             ( Fill in examples of interesting compositions).
       Each Cand also has a list of reasons explaining why it was
 proposed,  and a numeric rating of its overall value.

       DO-THRESHhold is a numeric variable that indicates the lowest
 rating a Cand may have and still be executed by AM.
 If no Cand on CANDS measures up,  then all the concepts try to suggest 
new candidates,  which are merged into CANDS.
      

       DISCLAIMER: The user interface is still unfinished,  and in fact 
the only polished part is the following message describing it!  Try it 
at your own risk! 


       You,  Ed,  can affect this concept growing process.
 At any time,  you may hit ↑I,  which will Interrupt me.
 Once interrupted,  I will answer one question or perform one task;
 a typical question I can answer is WHY;
 a typical task is ( Raise the Interest Level of the Frobnate Concept).
       A second way to interact with me is to help me decide
 which Cand to do next each time. You can see my top choices,  their
 reasons,  and overrule me if you want. The variable Seencands is
 the number of Candidates you see each time,  and Ucontrol indicates
 the amount of control you have over my choosing.

       To keep you informed,  I will periodically print out messages.
 The level of verbosity can be changed by interrupting me.

      More details can be obtained when you interrupt with ↑I.

Verbosity Level (1 - 10, or ?) ....  ( Please terminate your response 
with a carriage-return) ...?

       Verbosity = the amount of data that AM spews out to Ed.
       In this system,  Verbosity is just a numeric-valued variable
             which the Printing functions look at.
       Verbosity level 0 suppresses all messages.
       Verbosity level 5 lets most important messages get printed.
       Verbosity level 10 dumps out enough to actually get some
             feeling for the inner workings of AM.

       The suggested value for Ed is 8.

Verbosity Level (1 - 10, or ?) ....  ( Please terminate your response 
with a carriage-return) ...10
 User-control Level ( 0 - 10,  or ? ) ....?

       User-control = the degree to which you supervise AM's activities
       In this system,  User-control is just a numeric-valued variable
             which the top-level control functions look at.
       User-control level 0 lets you gain control only via ↑I.
       User-control level 5 lets you see a few of AM's alternatives, 
             and waits 6 seconds for you to OK its choice.
       User-control level 10 displays several alternative Candidates, 
             and waits indefinitely until you to select one.

 User-control Level ( 0 - 10,  or ? ) ....4

 Before deciding which new Cand to work on, I'll print my top choices.

 How many Candidates would you like to see each time?  
       ( I suggest  4): 3

 Should I tell you my reasons for each Cand I am considering selecting 
each time?   
No

 Should I tell you my reasons for the Cand I actually select each time? 
  
Yes

       If you have not typed anything within 4 seconds after a prompt,  
then AM will fill in a default answer for you.
 A space will suffice to keep AM from defaulting on you, 
 while you think about what to reply to any question AM asks you.
 In general,  your response should be terminated by a carriage return.

 Would you like to reset this waiting time?  N
 no

Entering AM's main loop now.

 No Cand on CANDS is good enuf.
 Do-thresh reduced from 500 to 333
 Must find new candidates and merge them into CANDS.
(ACTIVE-EXS-E-SUGG compiling)
(ACTIVE-EXS-E-SUGG (BA1 BA2 BA3) NIL)
(ACTIVE-EXS-NOT-BDY-E-SUGG compiling)
(ACTIVE-EXS-NOT-BDY-E-SUGG (BA1 BA2 BA3) NIL)
(ANYB-D-R-E-SUGG compiling)
(ANYB-D-R-E-SUGG (BA1 BA2 BA3) NIL)
(ANYB-EXS-E-SUGG compiling)
(ANYB-EXS-E-SUGG (BA1 BA2 BA3) NIL)
πinterrupted before GETP

(GETP broken)
:BREAK(XEQ-CAND)
(XEQ-CAND)
:
OK
GETP
(ANYB-EXS-BDY-E-SUGG compiling)
(ANYB-EXS-BDY-E-SUGG (BA1 BA2 BA3) NIL)
(CANONIZE-E-SUGG compiling)
(CANONIZE-E-SUGG (BA1 BA2 BA3) NIL)
(COALESCE-E-SUGG compiling)
(COALESCE-E-SUGG (BA1 BA2 BA3) NIL)
(INV-OP-E-SUGG compiling)
(INV-OP-E-SUGG (BA1 BA2 BA3) NIL)
(MAP-JOIN-E-SUGG compiling)
(MAP-JOIN-E-SUGG (BA1 BA2 BA3) NIL)
(MAP-REPLACE-E-SUGG compiling)
(MAP-REPLACE-E-SUGG (BA1 BA2 BA3) NIL)
(MAP-REPLACE2-E-SUGG compiling)
(MAP-REPLACE2-E-SUGG (BA1 BA2 BA3) NIL)
(RESTRICT-E-SUGG compiling)
(RESTRICT-E-SUGG (BA1 BA2 BA3) NIL)



 The top 3 Cands are:
    1: Fill in some examples of Set-struc-intersect
    2: Fill in some examples of Set-struc
    3: Fill in some examples of Bag-struc

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (We have no examples
for SET-STRUC-INTERSECT yet)


      Beginning 1st cycle.

(XEQ-CAND broken)
:EVAL

(ANYB-ANYP-E-FILLIN1 compiling)
(ANYB-ANYP-E-FILLIN1 (BA1) NIL)
(ANYB-EXS-E-FILLIN1 compiling)
(ANYB-EXS-E-FILLIN1 (BA1) NIL)
(ACTIVE-EXS-E-FILLIN1 compiling)
(ACTIVE-EXS-E-FILLIN1 (BA1) NIL)
(ANYB-EXS-E-FILLIN2 compiling)
(ANYB-EXS-E-FILLIN2 (BA1) (BA2))
 Won't try to create a restricted interesting version of 
SET-STRUC-INTERSECT.

Failed.  Tried to fill in new examples of SET-STRUC-INTERSECT.
XEQ-CAND evaluated
:(CAR CANDS)
((FILLIN SET-STRUC EXS) 407 ((Active-exs specifically asked for some
examples of SET-STRUC ", " while trying to "Fill in some" 
Set-struc-intersect "examples") (We have no examples for SET-STRUC
yet)))
:
OK
XEQ-CAND
π

?:  (W, I, E, M, N, ?, Q) ?

 Here are more detailed explanations of your options:
 W       Why: AM gives Ed the explanation behind its last printed
             message.
 I       Interest: Ed can modify the interest ratings of concepts and
             Candidates.
 E       Evaluate: Ed types in an expression and AM runs EVAL on it.
 M       Message: What was the last message that AM did NOT type out
             because the verbosity was too low? 
 N       Name: Rename some concept to whatever you want to call it.
 Q       Quit: resume execution.

 In general,  AM will automatically resume execution after answering one
 query. You must hit ↑I again to interrupt.


?:  (W, I, E, M, N, ?, Q) W
       Why: (No examples of SET-STRUC-INTERSECT were found; there
is no reason to even consider specializing it further)


 This Cand used 11.159 cpu seconds.




 The top 3 Cands are:
    1: Fill in some examples of Set-struc
    2: Fill in some examples of Bag-struc
    3: Fill in some examples of Obj-equal

 I choose first Cand.       OK?   yes.

       The 2 reasons for considering this Cand are:
      (Active-exs specifically asked for some examples of SET-STRUC
,  while trying to Fill in some Set-struc-intersect examples)
      (We have no examples for SET-STRUC yet)


      Beginning 2nd cycle.

(XEQ-CAND broken)
:OK

(CONSTRUCTIVE-OP-E-DEFN compiling)
(CONSTRUCTIVE-OP-E-DEFN (BA1 BA2 BA3) NIL)
(STRUCTURE-DELETE-E-INV compiling)
(STRUCTURE-DELETE-E-INV (BA1 BA2 BA3 BA4 BA5) NIL)
(STRUCTURE-MEMB-E-INV compiling)
(STRUCTURE-MEMB-E-INV (BA1 BA2 BA3 BA4 BA5) NIL)
(STRUCTURE-INSERT-E-ALGS compiling)
(STRUCTURE-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(EMPTY-STRUC-E-DEFN compiling)
(EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(SET-STRUC-E-DEFN compiling)
(SET-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(BAG-STRUC-E-DEFN compiling)
(BAG-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(OSET-STRUC-E-DEFN compiling)
(OSET-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(LIST-STRUC-E-DEFN compiling)
(LIST-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(STRUCTURE-EXS-E-FILLIN2 compiling)
(STRUCTURE-EXS-E-FILLIN2 (BA1) NIL)
(OBJECT-E-VIEW compiling)
(OBJECT-E-VIEW (BA1 BA2 BA3 BA4) NIL)
(STRUCTURE-E-VIEW compiling)
(STRUCTURE-E-VIEW (BA1 BA2 BA3 BA4) NIL)
(SET-STRUC-INSERT-E-ALGS compiling)
(SET-STRUC-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
(STRUCTURE-DELETE-E-ALGS compiling)
(STRUCTURE-DELETE-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)

 Creating new Being,  similar to SET-STRUC,  named INT-SET-STRUC,  but 
restricted so as to make it more interesting.
       An INT-SET-STRUC is any SET-STRUC for which (Each pair of 
elements satisfies the same interesting predicate P (for some P)).

 Filled in examples of SET-STRUC.
       0 examples existed originally on SET-STRUC.
       11 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      (CLASS)
      (CLASS DOUG CORDELL BRUCE)
      (CLASS R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7)
      (CLASS A)
      (CLASS B)
      (CLASS A B)
      (CLASS 0 D F I M)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 7 new,  distinct examples of SET-STRUC had to be added.


XEQ-CAND

 Do-thresh raised from 332 to 346 because this last Cand succeeded,  so 
we raise our hopes-- and our standards-- temporarily.

 This Cand used 23.743 cpu seconds.




 The top 3 Cands are:
    1: Fill in some examples of Int-set-struc
    2: Fill in some examples of Obj-equal
    3: Check all examples of Set-struc

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (Any example of 
INT-SET-STRUC is automatically an interesting example of SET-STRUC)


      Beginning 3rd cycle.

(XEQ-CAND broken)
:OK

(INT-SET-STRUC-E-DEFN compiling)
(INT-SET-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))
(OBJ-EQUAL-E-ALGS compiling)
(OBJ-EQUAL-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
 Won't try to create a restricted interesting version of INT-SET-STRUC.

 Filled in examples of INT-SET-STRUC.
       0 examples existed originally on INT-SET-STRUC.
       13 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      (CLASS)
      (CLASS A)
      (CLASS B)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 3 new,  distinct examples of INT-SET-STRUC had to be added.


XEQ-CAND

 Do-thresh raised from 346 to 358.

 This Cand used 11.881 cpu seconds.




 The top 3 Cands are:
    1: Fill in some examples of Obj-equal
    2: Check all examples of Int-set-struc
    3: Check all examples of Set-struc

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (We have no examples
for OBJ-EQUAL yet)


      Beginning 4th cycle.

(XEQ-CAND broken)
:EVAL

(OBJ-EQUAL-E-DEFN compiling)
(OBJ-EQUAL-E-DEFN (BA1 BA2 BA3) NIL)

 Record of attempts to find examples:---
 An ex ( sought) is: ((CLASS A B) (CLASS A B))+-------------------------
+-------+-------------------------+-----+--------------------+----------
--++--------------+----------+--------------+----------------

 Found 11 examples ( and 151 non-exs),  in 7.231 secs.
 A nice ratio of exs/non-exs was encountered for OBJ-EQUAL
 Won't try to create a restricted interesting version of OBJ-EQUAL.

 Filled in examples of OBJ-EQUAL.
       0 examples existed originally on OBJ-EQUAL.
       12 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      ((VECTOR) (VECTOR) T)
      ((CLASS A B) (CLASS A B) T)
      ((CLASS A) (CLASS A) T)
      ((VECTOR A B) (VECTOR A B) T)
      ((VECTOR A) (VECTOR A) T)
      (NIL NIL T)
      ((VECTOR B) (VECTOR B) T)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 7 new,  distinct examples of OBJ-EQUAL had to be added.


XEQ-CAND evaluated
:PUT(OBJ-EQUAL EXS)
NIL
:
EVAL


 Record of attempts to find examples:-----------------------------------
--------------
 An ex ( sought) is: ((VECTOR) (VECTOR))+---------+--------------+------
--------+-+--+-+--+---------+-----------------+-------------------------
--------

 Found 10 examples ( and 151 non-exs),  in 7.24 secs.
 A nice ratio of exs/non-exs was encountered for OBJ-EQUAL
 Won't try to create a restricted interesting version of OBJ-EQUAL.

 Filled in examples of OBJ-EQUAL.
       0 examples existed originally on OBJ-EQUAL.
       11 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      (NIL NIL T)
      ((VECTOR) (VECTOR) T)
      ((CLASS B) (CLASS B) T)
      ((CLASS R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7) (CLASS R0-7
R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7) T)
      ((VECTOR BAG) (VECTOR BAG) T)
      ((VECTOR A A B) (VECTOR A A B) T)
      (TRUE TRUE T)
      ((CLASS A B) (CLASS A B) T)
      ((VECTOR A B) (VECTOR A B) T)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 9 new,  distinct examples of OBJ-EQUAL had to be added.


XEQ-CAND evaluated
:PUT(OBJ-EQUAL EXS)
NIL
:
EVAL


 Record of attempts to find examples:-
 An ex ( sought) is: ((VECTOR) (VECTOR))+---------------------------+---
-------
GC: 8
 Walking at 22277  Load av. =  3.12, used 0:02:20.4 in 0:10:03
 Walking at 22667  Load av. =  3.76, used 0:02:31.3 in 0:10:39
31092, 31092 FREE WORDS
-------+------------------------------+-+---------+---------------------
---+----+---------------+-+-+---------------------

 Found 11 examples ( and 151 non-exs),  in 8.485 secs.
 A nice ratio of exs/non-exs was encountered for OBJ-EQUAL
 Won't try to create a restricted interesting version of OBJ-EQUAL.

 Filled in examples of OBJ-EQUAL.
       0 examples existed originally on OBJ-EQUAL.
       12 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      ((VECTOR) (VECTOR) T)
      (FALSE FALSE T)
      (TRUE TRUE T)
      ((VECTOR BAG) (VECTOR BAG) T)
      ((VECTOR A) (VECTOR A) T)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 5 new,  distinct examples of OBJ-EQUAL had to be added.


XEQ-CAND evaluated
:PUT(OBJ-EQUAL EXS)
NIL
:
EVAL


 Record of attempts to find examples:------------------------
 An ex ( sought) is: ((VECTOR) (VECTOR))+---------------+--------+---+--
+-+-----+--+-+--πinterrupted before OBJ-EQUAL-E-ALGS

   (OBJ-EQUAL-E-ALGS broken)
:BT
OBJ-EQUAL-E-ALGS
PROGN
APPLY
SELECTQ
OBJ-EQUAL
APPLYB
EVAL
AC-EXS-FILLIN1
ACTIVE-EXS-E-FILLIN1
PROGN
APPLY
SELECTQ
ACTIVE-EXS
FILLIN1
FILLIN
EVAL
XEQ-CANDB0007
**BREAK**
XEQ-CAND
TLOOP
START
**TOP**

:BTV
OBJ-EQUAL-E-ALGS
PROGN
APPLY

   SELCQ (BP (ALGS &) (DEFN &) NIL)
SELECTQ

   BA4 NIL
   BA3 NIL
   BA2 (VECTOR B (BAG B) (CLASS) A)
   BA1 (CLASS A)
   BP ALGS
OBJ-EQUAL

   BA2 (VECTOR B (BAG B) (CLASS) A)
   BA1 (CLASS A)
   BP ALGS
APPLYB
EVAL

   NEK2 63
   EK2 9
   RLST (T (& & T) (& & T) (& & T) (& & T) (& & T) (& & T) (& & T)
(& & T) (& & T))
   CORG 148480
   TKNT 185480

   F1 RANDQMEMB
AC-EXS-FILLIN1

   BA1 NIL
ACTIVE-EXS-E-FILLIN1
PROGN
APPLY

   SELCQ (BP (SUGG &) (FILLIN1 &) NIL)
SELECTQ

   BA4 NIL
   BA3 NIL
   BA2 NIL
   BA1 NIL
   BP FILLIN1
ACTIVE-EXS

   B ACTIVE-EXS
FILLIN1

   MACROW ((& & T))
   MACROZ ((& & T))
   MACROY ((& & T))
   MACROF FILLIN1
   MACROX (ACTIVE-EXS)

   EPP NIL
   RRS (ANYTHING ANYB ANYB-ANYP ANYB-EXS ACTIVE-EXS)
   PP EXS
   RS (ACTIVE-EXS ANYB-EXS ANYB-ANYP ANYB ANYTHING)
   BA2 NIL
   BA1 EXS
   B OBJ-EQUAL
FILLIN
EVAL
XEQ-CANDB0007
**BREAK**
XEQ-CAND
TLOOP
START
**TOP**

:ADVISE OBJ-EQUAL RETURN NIL
 Limping at 10570  Load av. =  6.89, used 0:02:55.9 in 0:13:46
u.b.a.
RETURN
(OBJ-EQUAL-E-ALGS broken)
: Crawling at 6620  Load av. =  7.32, used 0:02:56.7 in 0:14:07
EDITF(OBJ-EQUAL)
edit

*EDITF(OBJ-EQUAL)
=E EDITF
edit

*P
(LAMBDA (BP BA1 BA2 BA3 BA4) (SELECTQ BP & & NIL))
*(N NIL)

*OK
OBJ-EQUAL
*OK
OBJ-EQUAL
: IO wait at 16131  Load av. =  6.41, used 0:03:00.0 in 0:15:31
OK
OBJ-EQUAL-E-ALGS
------------------------------------------------------------------------
----------------

 Found 9 examples ( and 151 non-exs),  in 17.298 secs.
 A nice ratio of exs/non-exs was encountered for OBJ-EQUAL
 Won't try to create a restricted interesting version of OBJ-EQUAL.

 Filled in examples of OBJ-EQUAL.
       0 examples existed originally on OBJ-EQUAL.
       10 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      ((VECTOR BAG) (VECTOR BAG) T)
      ((VECTOR) (VECTOR) T)
      ((CLASS R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7) (CLASS R0-7
R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7) T)
      ((CLASS DOUG CORDELL BRUCE) (CLASS DOUG CORDELL BRUCE) T)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 4 new,  distinct examples of OBJ-EQUAL had to be added.


XEQ-CAND evaluated
:PUT(OBJ-EQUAL EXS)
NIL
:
EVAL


 Record of attempts to find examples:-----------------------------------
------------------------------------------πinterrupted before APPEND

   (APPEND broken)
:OK
APPEND
----------------------------πinterrupted before RAND

   (RAND broken)
:EDITF(OBJ-EQUAL)
edit

*-1
*(:)

*OK
OBJ-EQUAL
:OK
RAND
---
 An ex ( sought) is: ((VECTOR BAG) (VECTOR BAG))+----------------------+
----+----------++------+-

 Found 6 examples ( and 151 non-exs),  in 11.644 secs.
 Ratio of exs to non-exs is too low ( 6 / 151); Exs are too sparse.
       AM will sometime try to generalize OBJ-EQUAL.
 Won't try to create a restricted interesting version of OBJ-EQUAL.

 Filled in examples of OBJ-EQUAL.
       0 examples existed originally on OBJ-EQUAL.
       6 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      ((VECTOR BAG) (VECTOR BAG) T)
      ((VECTOR) (VECTOR) T)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 2 new,  distinct examples of OBJ-EQUAL had to be added.


XEQ-CAND evaluated
:OK
XEQ-CAND

 Do-thresh raised from 358 to 359.

 This Cand used 17.886 cpu seconds.


 No Cand on CANDS is good enuf.
 Do-thresh reduced from 359 to 239
 Must find new candidates and merge them into CANDS.
(INT-SET-STRUC-E-SUGG compiling)
(INT-SET-STRUC-E-SUGG (BA1 BA2 BA3) NIL)
(ACTIVE-E-DEFN-SUF compiling)
(ACTIVE-E-DEFN-SUF (BA1 BA2 BA3 BA4) NIL)



 The top 3 Cands are:
    1: Fill in some examples of Set-struc-intersect
    2: Fill in some examples of Bag-struc
    3: Check all examples of Int-set-struc

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (We have no examples
for SET-STRUC-INTERSECT yet)

 AM recently tried this same Cand,  so let's skip it now.



 The top 3 Cands are:
    1: Fill in some examples of Bag-struc
    2: Check all examples of Int-set-struc
    3: Check all examples of Set-struc

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (We have no examples
for BAG-STRUC yet)


      Beginning 5th cycle.

(XEQ-CAND broken)
:ub
=UB
(XEQ-CAND)
:OK

 Walking at 1467  Load av. =  4.95, used 0:03:54.8 in 0:26:41
(BAG-STRUC-INSERT-E-ALGS compiling)
(BAG-STRUC-INSERT-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
 Won't try to create a restricted interesting version of BAG-STRUC.

 Filled in examples of BAG-STRUC.
       0 examples existed originally on BAG-STRUC.
       19 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      (BAG)
      (BAG A)
      (BAG B)
      (BAG A B)
      (BAG A A)
      (BAG A A B)
      (BAG 0 D F I M)
      (BAG A B (BAG B) (CLASS))
      (BAG BRUCE CORDELL DOUG)
      (BAG R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 10 new,  distinct examples of BAG-STRUC had to be added.


XEQ-CAND

 Do-thresh raised from 238 to 264.

 This Cand used 17.692 cpu seconds.

 AM is forgetting the entire SUGG facet of the INT-SET-STRUC concept.
       Because: (No sense using this suggestion more than once).
 AM is forgetting the entire SUGG facet of the INT-SET-STRUC concept.
       Because: (No sense using this suggestion more than once).



 The top 3 Cands are:
    1: Check all examples of Int-set-struc
    2: Check all examples of Set-struc
    3: Check all examples of Set-struc-intersect

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (Some new ,  unchecked
examples of INT-SET-STRUC have recently been added)


      Beginning 6th cycle.

(ANYB-EXS-E-CHECK1 compiling)
(ANYB-EXS-E-CHECK1 (BA1) NIL)
(OBJECT-EXS-E-CHECK1 compiling)
(OBJECT-EXS-E-CHECK1 (BA1) NIL)
(INT-SET-STRUC-E-DEFN compiling)
(INT-SET-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))
(NONMULT-STRUC-EXS-E-CHECK1 compiling)
(NONMULT-STRUC-EXS-E-CHECK1 (BA1) NIL)
(UNORD-OBJ-EXS-E-CHECK1 compiling)
(UNORD-OBJ-EXS-E-CHECK1 (BA1) NIL)
(ANYB-EXS-E-CHECK2 compiling)
(ANYB-EXS-E-CHECK2 (BA1) NIL)
 Checked examples of INT-SET-STRUC and all entries were confirmed

 This Cand used 11.362 cpu seconds.




 The top 3 Cands are:
    1: Fill in some conjectures involving the concept of Int-set-struc
    2: Check all examples of Set-struc
    3: Check all examples of Set-struc-intersect

 I choose first Cand.       OK?   yes.

       The reason for considering this Cand is: (Examples of 
INT-SET-STRUC remain after checking ,  to compare against other concepts
**)



      Beginning 7th cycle.

(ANYB-TIES-E-FILLIN1 compiling)
(ANYB-TIES-E-FILLIN1 (BA1) NIL)
(NON-EMPTY-STRUC-E-DEFN compiling)
(NON-EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) NIL)
(ORD-PAIR-E-DEFN compiling)
(ORD-PAIR-E-DEFN (BA1 BA2 BA3) NIL)
(BAG-OF-LISTS-E-DEFN compiling)
(BAG-OF-LISTS-E-DEFN (BA1 BA2 BA3) NIL)
(SET-OF-LISTS-E-DEFN compiling)
(SET-OF-LISTS-E-DEFN (BA1 BA2 BA3) NIL)

GC: 8
30227, 30227 FREE WORDS
(BAG-OF-STRUCS-E-DEFN compiling)
(BAG-OF-STRUCS-E-DEFN (BA1 BA2 BA3) NIL)
(TRUTH-VAL-E-DEFN compiling)
(TRUTH-VAL-E-DEFN (BA1 BA2 BA3) NIL)
(ATOM-OBJ-E-DEFN compiling)
(ATOM-OBJ-E-DEFN (BA1 BA2 BA3) NIL)
(SET-OF-STRUCS-E-DEFN compiling)
(SET-OF-STRUCS-E-DEFN (BA1 BA2 BA3) NIL)
(STRUCTURE-E-DEFN compiling)
(STRUCTURE-E-DEFN (BA1 BA2 BA3) NIL)
(STRUC-OF-LISTS-E-DEFN compiling)
(STRUC-OF-LISTS-E-DEFN (BA1 BA2 BA3) NIL)
(STRUC-OF-STRUCS-E-DEFN compiling)
(STRUC-OF-STRUCS-E-DEFN (BA1 BA2 BA3) NIL)

GC: 1
 Walking at 22277  Load av. =  3.67, used 0:05:07.2 in 0:33:51